/*
 * aes.js: implements AES - Advanced Encryption Standard
 * from the SlowAES project, http://code.google.com/p/slowaes/
 *
 * Copyright (c) 2008   Josh Davis ( http://www.josh-davis.org ),
 *                                              Mark Percival ( http://mpercival.com ),
 *
 * Ported from C code written by Laurent Haan ( http://www.progressive-coding.com )
 *
 * Licensed under the Apache License, Version 2.0
 * http://www.apache.org/licenses/
 */

var slowAES = {
        /*
         * START AES SECTION
         */
        aes:{
                // structure of valid key sizes
                keySize:{
                        SIZE_128:16,
                        SIZE_192:24,
                        SIZE_256:32
                },
               
                // Rijndael S-box
                sbox:[
                0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
                0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
                0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
                0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
                0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
                0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
                0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
                0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
                0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
                0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
                0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
                0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
                0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
                0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
                0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
                0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 ],
               
                // Rijndael Inverted S-box
                rsbox:
                [ 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb
                , 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb
                , 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e
                , 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25
                , 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92
                , 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84
                , 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06
                , 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b
                , 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73
                , 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e
                , 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b
                , 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4
                , 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f
                , 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef
                , 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61
                , 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d ],
               
                /* rotate the word eight bits to the left */
                rotate:function(word)
                {
                        var c = word[0];
                        for (var i = 0; i < 3; i++)
                                word[i] = word[i+1];
                        word[3] = c;
                       
                        return word;
                },
               
                // Rijndael Rcon
                Rcon:[
                0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
                0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
                0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
                0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d,
                0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab,
                0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d,
                0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25,
                0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01,
                0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d,
                0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa,
                0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a,
                0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02,
                0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
                0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
                0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
                0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
                0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f,
                0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5,
                0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33,
                0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb ],

                G2X: [
                0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16,
                0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e,
                0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46,
                0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
                0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76,
                0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e,
                0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6,
                0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
                0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6,
                0xd8, 0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee,
                0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x1b, 0x19, 0x1f, 0x1d,
                0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05,
                0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d,
                0x23, 0x21, 0x27, 0x25, 0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55,
                0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45, 0x7b, 0x79, 0x7f, 0x7d,
                0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65,
                0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d,
                0x83, 0x81, 0x87, 0x85, 0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5,
                0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5, 0xdb, 0xd9, 0xdf, 0xdd,
                0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
                0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed,
                0xe3, 0xe1, 0xe7, 0xe5
                ],

                G3X: [
                0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d,
                0x14, 0x17, 0x12, 0x11, 0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39,
                0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21, 0x60, 0x63, 0x66, 0x65,
                0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
                0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d,
                0x44, 0x47, 0x42, 0x41, 0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9,
                0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1, 0xf0, 0xf3, 0xf6, 0xf5,
                0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1,
                0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd,
                0xb4, 0xb7, 0xb2, 0xb1, 0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99,
                0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81, 0x9b, 0x98, 0x9d, 0x9e,
                0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a,
                0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6,
                0xbf, 0xbc, 0xb9, 0xba, 0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2,
                0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea, 0xcb, 0xc8, 0xcd, 0xce,
                0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda,
                0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46,
                0x4f, 0x4c, 0x49, 0x4a, 0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62,
                0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a, 0x3b, 0x38, 0x3d, 0x3e,
                0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
                0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16,
                0x1f, 0x1c, 0x19, 0x1a
                ],

                G9X: [
                0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53,
                0x6c, 0x65, 0x7e, 0x77, 0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf,
                0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7, 0x3b, 0x32, 0x29, 0x20,
                0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
                0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8,
                0xc7, 0xce, 0xd5, 0xdc, 0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49,
                0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01, 0xe6, 0xef, 0xf4, 0xfd,
                0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91,
                0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e,
                0x21, 0x28, 0x33, 0x3a, 0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2,
                0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa, 0xec, 0xe5, 0xfe, 0xf7,
                0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b,
                0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f,
                0x10, 0x19, 0x02, 0x0b, 0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8,
                0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0, 0x47, 0x4e, 0x55, 0x5c,
                0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30,
                0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9,
                0xf6, 0xff, 0xe4, 0xed, 0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35,
                0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d, 0xa1, 0xa8, 0xb3, 0xba,
                0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
                0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62,
                0x5d, 0x54, 0x4f, 0x46
                ],

                GBX: [
                0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45,
                0x74, 0x7f, 0x62, 0x69, 0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81,
                0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9, 0x7b, 0x70, 0x6d, 0x66,
                0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
                0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e,
                0xbf, 0xb4, 0xa9, 0xa2, 0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7,
                0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f, 0x46, 0x4d, 0x50, 0x5b,
                0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f,
                0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8,
                0xf9, 0xf2, 0xef, 0xe4, 0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c,
                0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54, 0xf7, 0xfc, 0xe1, 0xea,
                0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e,
                0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02,
                0x33, 0x38, 0x25, 0x2e, 0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd,
                0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5, 0x3c, 0x37, 0x2a, 0x21,
                0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55,
                0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44,
                0x75, 0x7e, 0x63, 0x68, 0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80,
                0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8, 0x7a, 0x71, 0x6c, 0x67,
                0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
                0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f,
                0xbe, 0xb5, 0xa8, 0xa3
                ],

                GDX: [
                0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f,
                0x5c, 0x51, 0x46, 0x4b, 0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3,
                0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b, 0xbb, 0xb6, 0xa1, 0xac,
                0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
                0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14,
                0x37, 0x3a, 0x2d, 0x20, 0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e,
                0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26, 0xbd, 0xb0, 0xa7, 0xaa,
                0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6,
                0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9,
                0x8a, 0x87, 0x90, 0x9d, 0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25,
                0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d, 0xda, 0xd7, 0xc0, 0xcd,
                0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91,
                0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75,
                0x56, 0x5b, 0x4c, 0x41, 0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42,
                0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a, 0xb1, 0xbc, 0xab, 0xa6,
                0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa,
                0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8,
                0xeb, 0xe6, 0xf1, 0xfc, 0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44,
                0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c, 0x0c, 0x01, 0x16, 0x1b,
                0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
                0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3,
                0x80, 0x8d, 0x9a, 0x97
                ],

                GEX: [
                0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62,
                0x48, 0x46, 0x54, 0x5a, 0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca,
                0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba, 0xdb, 0xd5, 0xc7, 0xc9,
                0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
                0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59,
                0x73, 0x7d, 0x6f, 0x61, 0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87,
                0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7, 0x4d, 0x43, 0x51, 0x5f,
                0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17,
                0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14,
                0x3e, 0x30, 0x22, 0x2c, 0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc,
                0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc, 0x41, 0x4f, 0x5d, 0x53,
                0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b,
                0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3,
                0xe9, 0xe7, 0xf5, 0xfb, 0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0,
                0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0, 0x7a, 0x74, 0x66, 0x68,
                0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20,
                0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e,
                0xa4, 0xaa, 0xb8, 0xb6, 0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26,
                0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56, 0x37, 0x39, 0x2b, 0x25,
                0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
                0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5,
                0x9f, 0x91, 0x83, 0x8d
                ],
               
                // Key Schedule Core
                core:function(word,iteration)
                {
                        /* rotate the 32-bit word 8 bits to the left */
                        word = this.rotate(word);
                        /* apply S-Box substitution on all 4 parts of the 32-bit word */
                        for (var i = 0; i < 4; ++i)
                                word[i] = this.sbox[word[i]];
                        /* XOR the output of the rcon operation with i to the first part (leftmost) only */
                        word[0] = word[0]^this.Rcon[iteration];
                        return word;
                },
               
                /* Rijndael's key expansion
                 * expands an 128,192,256 key into an 176,208,240 bytes key
                 *
                 * expandedKey is a pointer to an char array of large enough size
                 * key is a pointer to a non-expanded key
                 */
                expandKey:function(key,size)
                {
                        var expandedKeySize = (16*(this.numberOfRounds(size)+1));
                       
                        /* current expanded keySize, in bytes */
                        var currentSize = 0;
                        var rconIteration = 1;
                        var t = [];   // temporary 4-byte variable
                       
                        var expandedKey = [];
                        for(var i = 0;i < expandedKeySize;i++)
                                expandedKey[i] = 0;
               
                        /* set the 16,24,32 bytes of the expanded key to the input key */
                        for (var j = 0; j < size; j++)
                                expandedKey[j] = key[j];
                        currentSize += size;
               
                        while (currentSize < expandedKeySize)
                        {
                                /* assign the previous 4 bytes to the temporary value t */
                                for (var k = 0; k < 4; k++)
                                        t[k] = expandedKey[(currentSize - 4) + k];
               
                                /* every 16,24,32 bytes we apply the core schedule to t
                                 * and increment rconIteration afterwards
                                 */
                                if(currentSize % size == 0)
                                        t = this.core(t, rconIteration++);
               
                                /* For 256-bit keys, we add an extra sbox to the calculation */
                                if(size == this.keySize.SIZE_256 && ((currentSize % size) == 16))
                                        for(var l = 0; l < 4; l++)
                                                t[l] = this.sbox[t[l]];
               
                                /* We XOR t with the four-byte block 16,24,32 bytes before the new expanded key.
                                 * This becomes the next four bytes in the expanded key.
                                 */
                                for(var m = 0; m < 4; m++) {
                                        expandedKey[currentSize] = expandedKey[currentSize - size] ^ t[m];
                                        currentSize++;
                                }
                        }
                        return expandedKey;
                },
               
                // Adds (XORs) the round key to the state
                addRoundKey:function(state,roundKey)
                {
                        for (var i = 0; i < 16; i++)
                                state[i] ^= roundKey[i];
                        return state;
                },
               
                // Creates a round key from the given expanded key and the
                // position within the expanded key.
                createRoundKey:function(expandedKey,roundKeyPointer)
                {
                        var roundKey = [];
                        for (var i = 0; i < 4; i++)
                                for (var j = 0; j < 4; j++)
                                        roundKey[j*4+i] = expandedKey[roundKeyPointer + i*4 + j];
                        return roundKey;
                },
               
                /* substitute all the values from the state with the value in the SBox
                 * using the state value as index for the SBox
                 */
                subBytes:function(state,isInv)
                {
                        for (var i = 0; i < 16; i++)
                                state[i] = isInv?this.rsbox[state[i]]:this.sbox[state[i]];
                        return state;
                },
               
                /* iterate over the 4 rows and call shiftRow() with that row */
                shiftRows:function(state,isInv)
                {
                        for (var i = 0; i < 4; i++)
                                state = this.shiftRow(state,i*4, i,isInv);
                        return state;
                },
               
                /* each iteration shifts the row to the left by 1 */
                shiftRow:function(state,statePointer,nbr,isInv)
                {
                        for (var i = 0; i < nbr; i++)
                        {
                                if(isInv)
                                {
                                        var tmp = state[statePointer + 3];
                                        for (var j = 3; j > 0; j--)
                                                state[statePointer + j] = state[statePointer + j-1];
                                        state[statePointer] = tmp;
                                }
                                else
                                {
                                        var tmp = state[statePointer];
                                        for (var j = 0; j < 3; j++)
                                                state[statePointer + j] = state[statePointer + j+1];
                                        state[statePointer + 3] = tmp;
                                }
                        }
                        return state;
                },

                // galois multiplication of 8 bit characters a and b
                galois_multiplication:function(a,b)
                {
                        var p = 0;
                        for(var counter = 0; counter < 8; counter++)
                        {
                                if((b & 1) == 1)
                                        p ^= a;
                                if(p > 0x100) p ^= 0x100;
                                var hi_bit_set = (a & 0x80); //keep p 8 bit
                                a <<= 1;
                                if(a > 0x100) a ^= 0x100; //keep a 8 bit
                                if(hi_bit_set == 0x80)
                                        a ^= 0x1b;
                                if(a > 0x100) a ^= 0x100; //keep a 8 bit
                                b >>= 1;
                                if(b > 0x100) b ^= 0x100; //keep b 8 bit
                        }
                        return p;
                },
               
                // galois multipication of the 4x4 matrix
                mixColumns:function(state,isInv)
                {
                        var column = [];
                        /* iterate over the 4 columns */
                        for (var i = 0; i < 4; i++)
                        {
                                /* construct one column by iterating over the 4 rows */
                                for (var j = 0; j < 4; j++)
                                        column[j] = state[(j*4)+i];
                                /* apply the mixColumn on one column */
                                column = this.mixColumn(column,isInv);
                                /* put the values back into the state */
                                for (var k = 0; k < 4; k++)
                                        state[(k*4)+i] = column[k];
                        }
                        return state;
                },

                // galois multipication of 1 column of the 4x4 matrix
                mixColumn:function(column,isInv)
                {
                        var mult = [];  
                        if(isInv)
                                mult = [14,9,13,11];
                        else
                                mult = [2,1,1,3];
                        var cpy = [];
                        for(var i = 0; i < 4; i++)
                                cpy[i] = column[i];
                       
                        column[0] =     this.galois_multiplication(cpy[0],mult[0]) ^
                                        this.galois_multiplication(cpy[3],mult[1]) ^
                                        this.galois_multiplication(cpy[2],mult[2]) ^
                                        this.galois_multiplication(cpy[1],mult[3]);
                        column[1] =     this.galois_multiplication(cpy[1],mult[0]) ^
                                        this.galois_multiplication(cpy[0],mult[1]) ^
                                        this.galois_multiplication(cpy[3],mult[2]) ^
                                        this.galois_multiplication(cpy[2],mult[3]);
                        column[2] =     this.galois_multiplication(cpy[2],mult[0]) ^
                                        this.galois_multiplication(cpy[1],mult[1]) ^
                                        this.galois_multiplication(cpy[0],mult[2]) ^
                                        this.galois_multiplication(cpy[3],mult[3]);
                        column[3] =     this.galois_multiplication(cpy[3],mult[0]) ^
                                        this.galois_multiplication(cpy[2],mult[1]) ^
                                        this.galois_multiplication(cpy[1],mult[2]) ^
                                        this.galois_multiplication(cpy[0],mult[3]);
                        return column;
                },
               
                // applies the 4 operations of the forward round in sequence
                round:function(state, roundKey)
                {
                        state = this.subBytes(state,false);
                        state = this.shiftRows(state,false);
                        state = this.mixColumns(state,false);
                        state = this.addRoundKey(state, roundKey);
                        return state;
                },
               
                // applies the 4 operations of the inverse round in sequence
                invRound:function(state,roundKey)
                {
                        state = this.shiftRows(state,true);
                        state = this.subBytes(state,true);
                        state = this.addRoundKey(state, roundKey);
                        state = this.mixColumns(state,true);
                        return state;
                },
               
                /*
                 * Perform the initial operations, the standard round, and the final operations
                 * of the forward aes, creating a round key for each round
                 */
                main:function(state,expandedKey,nbrRounds)
                {
                        state = this.addRoundKey(state, this.createRoundKey(expandedKey,0));
                        for (var i = 1; i < nbrRounds; i++)
                                state = this.round(state, this.createRoundKey(expandedKey,16*i));
                        state = this.subBytes(state,false);
                        state = this.shiftRows(state,false);
                        state = this.addRoundKey(state, this.createRoundKey(expandedKey,16*nbrRounds));
                        return state;
                },
               
                /*
                 * Perform the initial operations, the standard round, and the final operations
                 * of the inverse aes, creating a round key for each round
                 */
                invMain:function(state, expandedKey, nbrRounds)
                {
                        state = this.addRoundKey(state, this.createRoundKey(expandedKey,16*nbrRounds));
                        for (var i = nbrRounds-1; i > 0; i--)
                                state = this.invRound(state, this.createRoundKey(expandedKey,16*i));
                        state = this.shiftRows(state,true);
                        state = this.subBytes(state,true);
                        state = this.addRoundKey(state, this.createRoundKey(expandedKey,0));
                        return state;
                },

                numberOfRounds:function(size)
                {
                        var nbrRounds;
                        switch (size) /* set the number of rounds */
                        {
                                case this.keySize.SIZE_128:
                                        nbrRounds = 10;
                                        break;
                                case this.keySize.SIZE_192:
                                        nbrRounds = 12;
                                        break;
                                case this.keySize.SIZE_256:
                                        nbrRounds = 14;
                                        break;
                                default:
                                        return null;
                                        break;
                        }
                        return nbrRounds;
                },
               
                // encrypts a 128 bit input block against the given key of size specified
                encrypt:function(input,key,size)
                {
                        var output = [];
                        var block = []; /* the 128 bit block to encode */
                        var nbrRounds = this.numberOfRounds(size);
                        /* Set the block values, for the block:
                         * a0,0 a0,1 a0,2 a0,3
                         * a1,0 a1,1 a1,2 a1,3
                         * a2,0 a2,1 a2,2 a2,3
                         * a3,0 a3,1 a3,2 a3,3
                         * the mapping order is a0,0 a1,0 a2,0 a3,0 a0,1 a1,1 ... a2,3 a3,3
                         */
                        for (var i = 0; i < 4; i++) /* iterate over the columns */
                                for (var j = 0; j < 4; j++) /* iterate over the rows */
                                        block[(i+(j*4))] = input[(i*4)+j];
               
                        /* expand the key into an 176, 208, 240 bytes key */
                        var expandedKey = this.expandKey(key, size); /* the expanded key */
                        /* encrypt the block using the expandedKey */
                        block = this.main(block, expandedKey, nbrRounds);
                        for (var k = 0; k < 4; k++) /* unmap the block again into the output */
                                for (var l = 0; l < 4; l++) /* iterate over the rows */
                                        output[(k*4)+l] = block[(k+(l*4))];
                        return output;
                },
               
                // decrypts a 128 bit input block against the given key of size specified
                decrypt:function(input, key, size)
                {
                        var output = [];
                        var block = []; /* the 128 bit block to decode */
                        var nbrRounds = this.numberOfRounds(size);
                        /* Set the block values, for the block:
                         * a0,0 a0,1 a0,2 a0,3
                         * a1,0 a1,1 a1,2 a1,3
                         * a2,0 a2,1 a2,2 a2,3
                         * a3,0 a3,1 a3,2 a3,3
                         * the mapping order is a0,0 a1,0 a2,0 a3,0 a0,1 a1,1 ... a2,3 a3,3
                         */
                        for (var i = 0; i < 4; i++) /* iterate over the columns */
                                for (var j = 0; j < 4; j++) /* iterate over the rows */
                                        block[(i+(j*4))] = input[(i*4)+j];
                        /* expand the key into an 176, 208, 240 bytes key */
                        var expandedKey = this.expandKey(key, size);
                        /* decrypt the block using the expandedKey */
                        block = this.invMain(block, expandedKey, nbrRounds);
                        for (var k = 0; k < 4; k++)/* unmap the block again into the output */
                                for (var l = 0; l < 4; l++)/* iterate over the rows */
                                        output[(k*4)+l] = block[(k+(l*4))];
                        return output;
                }
        },
        /*
         * END AES SECTION
         */
         
        /*
         * START MODE OF OPERATION SECTION
         */
        //structure of supported modes of operation
        modeOfOperation:{
                OFB:0,
                CFB:1,
                CBC:2
        },
       
        // get a 16 byte block (aes operates on 128bits)
        getBlock: function(bytesIn,start,end,mode)
        {
                if(end - start > 16)
                        end = start + 16;
               
                return bytesIn.slice(start, end);
        },
       
        /*
         * Mode of Operation Encryption
         * bytesIn - Input String as array of bytes
         * mode - mode of type modeOfOperation
         * key - a number array of length 'size'
         * size - the bit length of the key
         * iv - the 128 bit number array Initialization Vector
         */
        encrypt: function (bytesIn, mode, key, iv)
        {
                var size = key.length;
                if(iv.length%16)
                {
                        throw 'iv length must be 128 bits.';
                }
                // the AES input/output
                var byteArray = [];
                var input = [];
                var output = [];
                var ciphertext = [];
                var cipherOut = [];
                // char firstRound
                var firstRound = true;
                if (mode == this.modeOfOperation.CBC)
                        this.padBytesIn(bytesIn);
                if (bytesIn !== null)
                {
                        for (var j = 0;j < Math.ceil(bytesIn.length/16); j++)
                        {
                                var start = j*16;
                                var end = j*16+16;
                                if(j*16+16 > bytesIn.length)
                                        end = bytesIn.length;
                                byteArray = this.getBlock(bytesIn,start,end,mode);
                                if (mode == this.modeOfOperation.CFB)
                                {
                                        if (firstRound)
                                        {
                                                output = this.aes.encrypt(iv, key, size);
                                                firstRound = false;
                                        }
                                        else
                                                output = this.aes.encrypt(input, key, size);
                                        for (var i = 0; i < 16; i++)
                                                ciphertext[i] = byteArray[i] ^ output[i];
                                        for(var k = 0;k < end-start;k++)
                                                cipherOut.push(ciphertext[k]);
                                        input = ciphertext;
                                }
                                else if (mode == this.modeOfOperation.OFB)
                                {
                                        if (firstRound)
                                        {
                                                output = this.aes.encrypt(iv, key, size);
                                                firstRound = false;
                                        }
                                        else
                                                output = this.aes.encrypt(input, key, size);
                                        for (var i = 0; i < 16; i++)
                                                ciphertext[i] = byteArray[i] ^ output[i];
                                        for(var k = 0;k < end-start;k++)
                                                cipherOut.push(ciphertext[k]);
                                        input = output;
                                }
                                else if (mode == this.modeOfOperation.CBC)
                                {
                                        for (var i = 0; i < 16; i++)
                                                input[i] = byteArray[i] ^ ((firstRound) ? iv[i] : ciphertext[i]);
                                        firstRound = false;
                                        ciphertext = this.aes.encrypt(input, key, size);
                                        // always 16 bytes because of the padding for CBC
                                        for(var k = 0;k < 16;k++)
                                                cipherOut.push(ciphertext[k]);
                                }
                        }
                }
                return cipherOut;
        },
       
        /*
         * Mode of Operation Decryption
         * cipherIn - Encrypted String as array of bytes
         * originalsize - The unencrypted string length - required for CBC
         * mode - mode of type modeOfOperation
         * key - a number array of length 'size'
         * size - the bit length of the key
         * iv - the 128 bit number array Initialization Vector
         */
        decrypt:function(cipherIn,mode,key,iv)
        {
                var size = key.length;
                if(iv.length%16)
                {
                        throw 'iv length must be 128 bits.';
                }
                // the AES input/output
                var ciphertext = [];
                var input = [];
                var output = [];
                var byteArray = [];
                var bytesOut = [];
                // char firstRound
                var firstRound = true;
                if (cipherIn !== null)
                {
                        for (var j = 0;j < Math.ceil(cipherIn.length/16); j++)
                        {
                                var start = j*16;
                                var end = j*16+16;
                                if(j*16+16 > cipherIn.length)
                                        end = cipherIn.length;
                                ciphertext = this.getBlock(cipherIn,start,end,mode);
                                if (mode == this.modeOfOperation.CFB)
                                {
                                        if (firstRound)
                                        {
                                                output = this.aes.encrypt(iv, key, size);
                                                firstRound = false;
                                        }
                                        else
                                                output = this.aes.encrypt(input, key, size);
                                        for (i = 0; i < 16; i++)
                                                byteArray[i] = output[i] ^ ciphertext[i];
                                        for(var k = 0;k < end-start;k++)
                                                bytesOut.push(byteArray[k]);
                                        input = ciphertext;
                                }
                                else if (mode == this.modeOfOperation.OFB)
                                {
                                        if (firstRound)
                                        {
                                                output = this.aes.encrypt(iv, key, size);
                                                firstRound = false;
                                        }
                                        else
                                                output = this.aes.encrypt(input, key, size);
                                        for (i = 0; i < 16; i++)
                                                byteArray[i] = output[i] ^ ciphertext[i];
                                        for(var k = 0;k < end-start;k++)
                                                bytesOut.push(byteArray[k]);
                                        input = output;
                                }
                                else if(mode == this.modeOfOperation.CBC)
                                {
                                        output = this.aes.decrypt(ciphertext, key, size);
                                        for (i = 0; i < 16; i++)
                                                byteArray[i] = ((firstRound) ? iv[i] : input[i]) ^ output[i];
                                        firstRound = false;
                                        for(var k = 0;k < end-start;k++)
                                                bytesOut.push(byteArray[k]);
                                        input = ciphertext;
                                }
                        }
                        if(mode == this.modeOfOperation.CBC)
                            this.unpadBytesOut(bytesOut);
                }
                return bytesOut;
        },
        padBytesIn: function(data) {
                var len = data.length;
                var padByte = 16 - (len % 16);
                for (var i = 0; i < padByte; i++) {
                        data.push(padByte);
                }
        },
        unpadBytesOut: function(data) {
                var padCount = 0;
                var padByte = -1;
                var blockSize = 16;
                for (var i = data.length - 1; i >= data.length-1 - blockSize; i--) {
                        if (data[i] <= blockSize) {
                                if (padByte == -1)
                                        padByte = data[i];
                                if (data[i] != padByte) {
                                        padCount = 0;
                                        break;
                                }
                                padCount++;
                        } else
                                break;
                        if (padCount == padByte)
                                break;
                }
                if (padCount > 0)
                        data.splice(data.length - padCount, padCount);
        }
        /*
         * END MODE OF OPERATION SECTION
         */
};


/*
* jsHash.js: implements AES - Advanced Encryption Standard
* from the SlowAES project, http://code.google.com/p/slowaes/
 *
 * Copyright (c) 2008   Josh Davis ( http://www.josh-davis.org )
 *
 * Licensed under the Apache License, Version 2.0
 * http://www.apache.org/licenses/
 *
 * sha2 portions adapted from jsSHA2 ( http://anmar.eu.org/projects/jssha2/ )
 * Copyright Angel Marin 2003-2004 - http://anmar.eu.org/
 * Distributed under the BSD License
 */
 
 var jsHash = {
        sha2:{
                chrsz:8,  /* bits per input character. 8 - ASCII; 16 - Unicode      */
                hexcase:0,/* hex output format. 0 - lowercase; 1 - uppercase        */
                safe_add:function(x, y)
                {
                        var lsw = (x & 0xFFFF) + (y & 0xFFFF);
                        var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
                        return (msw << 16) | (lsw & 0xFFFF);
                },
                S:function(X, n) {return ( X >>> n ) | (X << (32 - n));},
                R:function(X, n) {return ( X >>> n );},
                Ch:function(x, y, z) {return ((x & y) ^ ((~x) & z));},
                Maj:function(x, y, z) {return ((x & y) ^ (x & z) ^ (y & z));},
                Sigma0256:function(x) {return (this.S(x, 2) ^ this.S(x, 13) ^ this.S(x, 22));},
                Sigma1256:function(x) {return (this.S(x, 6) ^ this.S(x, 11) ^ this.S(x, 25));},
                Gamma0256:function(x) {return (this.S(x, 7) ^ this.S(x, 18) ^ this.R(x, 3));},
                Gamma1256:function(x) {return (this.S(x, 17) ^ this.S(x, 19) ^ this.R(x, 10));},
                core_sha256:function(m, l)
                {
                        var K = [       0x428A2F98,0x71374491,0xB5C0FBCF,0xE9B5DBA5,0x3956C25B,0x59F111F1,0x923F82A4,0xAB1C5ED5,
                                        0xD807AA98,0x12835B01,0x243185BE,0x550C7DC3,0x72BE5D74,0x80DEB1FE,0x9BDC06A7,0xC19BF174,
                                        0xE49B69C1,0xEFBE4786,0xFC19DC6,0x240CA1CC,0x2DE92C6F,0x4A7484AA,0x5CB0A9DC,0x76F988DA,
                                        0x983E5152,0xA831C66D,0xB00327C8,0xBF597FC7,0xC6E00BF3,0xD5A79147,0x6CA6351,0x14292967,
                                        0x27B70A85,0x2E1B2138,0x4D2C6DFC,0x53380D13,0x650A7354,0x766A0ABB,0x81C2C92E,0x92722C85,
                                        0xA2BFE8A1,0xA81A664B,0xC24B8B70,0xC76C51A3,0xD192E819,0xD6990624,0xF40E3585,0x106AA070,
                                        0x19A4C116,0x1E376C08,0x2748774C,0x34B0BCB5,0x391C0CB3,0x4ED8AA4A,0x5B9CCA4F,0x682E6FF3,
                                        0x748F82EE,0x78A5636F,0x84C87814,0x8CC70208,0x90BEFFFA,0xA4506CEB,0xBEF9A3F7,0xC67178F2];
                        var HASH = [0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19];
                        var W = [];
                        var a, b, c, d, e, f, g, h, i, j;
                        var T1, T2;
                       
                        /* append padding */
                        m[l >> 5] |= 0x80 << (24 - l % 32);
                        m[((l + 64 >> 9) << 4) + 15] = l;
                       
                        for ( var i = 0; i<m.length; i+=16 )
                        {
                                a = HASH[0];
                                b = HASH[1];
                                c = HASH[2];
                                d = HASH[3];
                                e = HASH[4];
                                f = HASH[5];
                                g = HASH[6];
                                h = HASH[7];
                               
                                for ( var j = 0; j<64; j++)
                                {
                                        if (j < 16)
                                                W[j] = m[j + i];
                                        else
                                                W[j] = this.safe_add(this.safe_add(this.safe_add(this.Gamma1256(W[j - 2]), W[j - 7]), this.Gamma0256(W[j - 15])), W[j - 16]);
                                       
                                        T1 = this.safe_add(this.safe_add(this.safe_add(this.safe_add(h, this.Sigma1256(e)), this.Ch(e, f, g)), K[j]), W[j]);
                                        T2 = this.safe_add(this.Sigma0256(a), this.Maj(a, b, c));
                                       
                                        h = g;
                                        g = f;
                                        f = e;
                                        e = this.safe_add(d, T1);
                                        d = c;
                                        c = b;
                                        b = a;
                                        a = this.safe_add(T1, T2);
                                }
                               
                                HASH[0] = this.safe_add(a, HASH[0]);
                                HASH[1] = this.safe_add(b, HASH[1]);
                                HASH[2] = this.safe_add(c, HASH[2]);
                                HASH[3] = this.safe_add(d, HASH[3]);
                                HASH[4] = this.safe_add(e, HASH[4]);
                                HASH[5] = this.safe_add(f, HASH[5]);
                                HASH[6] = this.safe_add(g, HASH[6]);
                                HASH[7] = this.safe_add(h, HASH[7]);
                        }
                        return HASH;
                },
               
                str2binb:function(str)
                {
                        var bin = [];
                        var mask = (1 << this.chrsz) - 1;
                        for(var i = 0; i < str.length * this.chrsz; i += this.chrsz)
                        bin[i>>5] |= (str.charCodeAt(i / this.chrsz) & mask) << (24 - i%32);
                        return bin;
                },
               
                binb2str:function(bin)
                {
                        var str = "";
                        var mask = (1 << this.chrsz) - 1;
                        for(var i = 0; i < bin.length * 32; i += this.chrsz)
                        str += String.fromCharCode((bin[i>>5] >>> (24 - i%32)) & mask);
                        return str;
                },
               
                binb2arr:function(bin)
                {
                        var array = [];
                        var mask = (1 << this.chrsz) - 1;
                        for(var i = 0; i < bin.length * 32; i += this.chrsz)
                        array.push((bin[i>>5] >>> (24 - i%32)) & mask);
                        return array;
                },
               
                binb2hex:function(binarray)
                {
                        var hex_tab = this.hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
                        var str = "";
                        for(var i = 0; i < binarray.length * 4; i++)
                        {
                                str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
                                hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);
                        }
                        return str;
                },
               
                hex_sha256:function(s){return this.binb2hex(this.core_sha256(this.str2binb(s),s.length * this.chrsz));},
                arr_sha256:function(s){return this.binb2arr(this.core_sha256(this.str2binb(s),s.length * this.chrsz));},
                str_sha256:function(s){return this.binb2str(this.core_sha256(this.str2binb(s),s.length * this.chrsz));}
        }
 };

 var cryptoHelpers = {
	        // encodes a unicode string to UTF8 (8 bit characters are critical to AES functioning properly)
	        encode_utf8:function(s)
	        {
	                try{return unescape(encodeURIComponent(s));}
	                catch(e){throw 'error during utf8 encoding: cryptoHelpers.encode_utf8.';}
	        },
	       
	        // decodes a UTF8 string back to unicode
	        decode_utf8:function(s)
	        {
	                try{return decodeURIComponent(escape(s));}
	                catch(e){throw('error during utf8 decoding: cryptoHelpers.decode_utf8.');}
	        },
	       
	        //convert a number array to a hex string
	        toHex:function()
	        {
	                var array = [];
	                if(arguments.length == 1 && arguments[0].constructor == Array)
	                        array = arguments[0];
	                else
	                        array = arguments;
	                var ret = '';
	                for(var i = 0;i < array.length;i++)
	                        ret += (array[i] < 16 ? '0' : '') + array[i].toString(16);
	                return ret.toLowerCase();
	        },
	       
	        //convert a hex string to a number array
	        toNumbers:function(s)
	        {
	                var ret = [];
	                s.replace(/(..)/g,function(s){
	                        ret.push(parseInt(s,16));
	                });
	                return ret;
	        },
	       
	        // get a random number in the range [min,max]
	        getRandom:function(min,max)
	        {
	                if(min === null)
	                        min = 0;
	                if(max === null)
	                        max = 1;
	                return Math.floor(Math.random()*(max+1)) + min;
	        },
	       
	        generateSharedKey:function(len)
	        {
	                if(len === null)
	                        len = 16;
	                var key = [];
	                for(var i = 0; i < len*2; i++)
	                        key.push(this.getRandom(0,255));
	                return key;
	        },
	       
	        generatePrivateKey:function(s,size)
	        {
	                var sha = jsHash.sha2.arr_sha256(s);
	                return sha.slice(0,size);
	        },

	        convertStringToByteArray: function(s)
	        {
	                var byteArray = [];
	                for(var i = 0;i < s.length;i++)
	                                {
	                                                byteArray.push(s.charCodeAt(i));
	                                }
	                return byteArray;
	        },

	        convertByteArrayToString: function(byteArray)
	        {
	                var s = '';
	                for(var i = 0;i < byteArray.length;i++)
	                                {
	                                                s += String.fromCharCode(byteArray[i])
	                                }
	                return s;
	        },
	       
	        base64: {
	                // Takes a Nx16x1 byte array and converts it to Base64
	                chars: [
	                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
	                'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
	                'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
	                'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
	                'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
	                'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
	                'w', 'x', 'y', 'z', '0', '1', '2', '3',
	                '4', '5', '6', '7', '8', '9', '+', '/',
	                '=', // for decoding purposes
	                ],
	       
	                encode_line: function(flatArr){
	                        var b64 = '';

	                        for (var i = 0; i < flatArr.length; i += 3){
	                                b64 += this.chars[flatArr[i] >> 2];
	                                b64 += this.chars[((flatArr[i] & 3) << 4) | (flatArr[i + 1] >> 4)];
	                                if (!(flatArr[i + 1] == null)){
	                                        b64 += this.chars[((flatArr[i + 1] & 15) << 2) | (flatArr[i + 2] >> 6)];
	                                }else{
	                                        b64 += '=';
	                                }
	                                if (!(flatArr[i + 2] == null)){
	                                        b64 += this.chars[flatArr[i + 2] & 63];
	                                }else{
	                                        b64 += '=';
	                                }
	                        }
	                        return b64;
	                },
	       
	                encode: function(flatArr)
	                {
	                        var b64 = this.encode_line(flatArr);
	                        // OpenSSL is super particular about line breaks
	                        var broken_b64 = b64.slice(0, 64) + '\n';
	                        for (var i = 1; i < (Math.ceil(b64.length / 64)); i++)
	                        {
	                                broken_b64 += b64.slice(i * 64, i * 64 + 64) + (Math.ceil(b64.length / 64) == i + 1 ? '': '\n');
	                        }
	                        return broken_b64;
	                },
	       
	            decode: function(string)
	                {
	                        string = string.replace(/[\r\n\t ]+/g, '') + '===='; // drop all whitespaces and pad with '=' (end of b64 marker)
	                        var flatArr = [];
	                        var c = [];
	                        var b = [];
	                        for (var i = 0; ; i = i + 4){
	                                c[0] = this.chars.indexOf(string.charAt(i));
	                                if(c[0] == 64){
	                                        return flatArr;
	                                }
	                                c[1] = this.chars.indexOf(string.charAt(i + 1));
	                                c[2] = this.chars.indexOf(string.charAt(i + 2));
	                                c[3] = this.chars.indexOf(string.charAt(i + 3));
	       
	                                if(
	                                        (c[0] < 0) || // char1 is wrong
	                                        (c[1] < 0) || (c[1] == 64) || // char2 is wrong
	                                        (c[2] < 0) || // char3 is neither an valid char nor '='
	                                        (c[3] < 0)    // char4 is neither an valid char nor '='
	                                ){
	                                        throw 'error during base64 decoding at pos '+i+': cryptoHelpers.base64.decode.';
	                                }
	       
	                                flatArr.push((c[0] << 2) | (c[1] >> 4));
	                                if(c[2] >= 0 && c[2] < 64){
	                                        flatArr.push(((c[1] & 15) << 4) | (c[2] >> 2));
	                                        if(c[3] >= 0 && c[2] < 64){
	                                                flatArr.push(((c[2] & 3) << 6) | c[3]);
	                                        }
	                                }
	                        }
	                },
	               
	        },
	       
	};

 
 
 function decrypt(input, key){

	    // Split the input into its compontents
	    var inputSplit = input.split(" ");
	    var originalSize = parseInt(inputSplit[0]);
	    var iv = cryptoHelpers.toNumbers(inputSplit[1]);
	    var cipherIn = cryptoHelpers.toNumbers(inputSplit[2]);

	    // Set up encryption parameters
	    var keyAsNumbers = cryptoHelpers.toNumbers( bin2hex( key ) );

	    var decrypted = slowAES.decrypt(
	        cipherIn,
	        slowAES.modeOfOperation.CBC,
	        keyAsNumbers,
	        iv
	    );

	    // Byte-array to text
	    var retVal = hex2bin(cryptoHelpers.toHex(decrypted));
	    retVal = cryptoHelpers.decode_utf8(retVal);

	    return retVal;
	}

	function encrypt( plaintext, key ){
		
		// Set up encryption parameters
	    plaintext = cryptoHelpers.encode_utf8(plaintext);
	    var inputData = cryptoHelpers.convertStringToByteArray(plaintext);
	    var keyAsNumber = cryptoHelpers.toNumbers(bin2hex(key));
	    var iv = cryptoHelpers.generateSharedKey(16);

	    var encrypted = slowAES.encrypt(
	        inputData,
	        slowAES.modeOfOperation.CBC,
	        keyAsNumber,
	        iv
	    );

	    // Set up output format (space delimeted "plaintextsize iv cipher")
	    var retVal = plaintext.length + " "
	        + cryptoHelpers.toHex(iv) + " "
	        + cryptoHelpers.toHex(encrypted);
	    return retVal;
	}

	// Equivilent to PHP bin2hex
	function bin2hex (s) {
	    var i, f = 0,
	        a = [];

	    s += '';
	    f = s.length;

	    for (i = 0; i < f; i++) {
	        a[i] = s.charCodeAt(i).toString(16).replace(/^([\da-f])$/, "0$1");
	    }

	    return a.join('');
	}

	// Equivilent to PHP hex2bin
	function hex2bin(hex) {
	    var str = '';
	    for (var i = 0; i < hex.length; i += 2)
	        str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
	    return str;
	}

